#ifndef __ITERATOR_H__
#define __ITERATOR_H__
// 两种形式的迭代器
// 可以加上一个数跳转过去的，还有一种就是只能++或者--的

/// @brief 随机访问迭代器
template <class Type>
class RandomAccessIterator
{
protected:
    int m_index{};  // 迭代器计数器
    Type *m_data{}; // 数据
    int m_size{};   // 数据总大小

protected:
    virtual void RANext(int index)
    {
        m_index += index;
    }
    virtual void RAPrevious()
    {
        m_index--;
    }
    virtual bool RAIsEmpty()
    {
        return m_index < 0 || m_index >= m_size;
    }
    virtual Type *RAGetItem()
    {
        return m_data + m_index;
    }

public:
    RandomAccessIterator(Type *beginItem, int size)
        : m_data(beginItem), m_size(size)
    {
    }
    /// @brief 下一个元素
    /// @param index 随机访问索引 当前位置 + (index)
    void Next(int index = 1) { RANext(index); }
    /// @brief 上一个元素
    void Previous() { RAPrevious(); }
    /// @brief 判断是否为空
    /// @return true 表示为空 false 表示不为空
    bool IsEmpty() { return RAIsEmpty(); }
    Type *GetItem() { return RAGetItem(); }
};
/// @brief 顺序访问迭代器
template <class Type>
class SequentialAccessIterator
{
protected:
    int m_index{};  // 迭代器计数器
    Type *m_data{}; // 数据
    int m_size{};   // 数据总大小

protected:
    virtual void SANext()
    {
        m_index++;
    }
    virtual void SAPrevious()
    {
        m_index--;
    }
    virtual bool SAIsEmpty()
    {
        return m_index < 0 || m_index >= m_size;
    }
    virtual Type *SAGetItem()
    {
        return m_data + m_index;
    }

public:
    SequentialAccessIterator(Type *beginItem, int size)
        : m_data(beginItem), m_size(size)
    {
    }
    /// @brief 下一个元素
    /// @param index 随机访问索引 当前位置 + (index)
    void Next() { SANext(); }
    /// @brief 上一个元素
    void Previous() { SAPrevious(); }
    /// @brief 判断是否为空
    /// @return true 表示为空 false 表示不为空
    bool IsEmpty() { return SAIsEmpty(); }
    Type *GetItem() { return SAGetItem(); }
};

class IntArray : public RandomAccessIterator<int>, public SequentialAccessIterator<int>
{
public:
    typedef RandomAccessIterator<int> *PIterator;
    typedef SequentialAccessIterator<int> *PSAIterator;

private:
    int arr[20]{1, 2, 3, 44, 55, 66, 34};

public:
    IntArray()
        : RandomAccessIterator<int>(arr, sizeof(arr) / sizeof(*arr)), SequentialAccessIterator<int>(arr, sizeof(arr) / sizeof(*arr))
    {
    }
    /// Iterator
    /*virtual void Next(int index = 1) override
    {
        m_index += index;
    }
    virtual void Previous() override
    {
        m_index--;
    }
    virtual bool IsEmpty() override
    {
        return m_index < 0 || m_index >= sizeof(arr) / sizeof(*arr);
    }*/
    PIterator CreateIteratorPointer()
    {
        return static_cast<PIterator>(this);
    }
    PSAIterator CreateSAIteratorPointer()
    {
        return static_cast<PSAIterator>(this);
    }
};

#endif